/**
 * 认证服务
 * 处理用户登录、注册、登出等认证相关功能
 */
import { BaseService } from '../../shared/services/base-service'
import type { ApiResponse, UserInfo } from '../../../types/api'
import { useUserStore } from '../stores/user'

// 登录请求参数
export interface LoginParams {
  username: string
  password: string
}

// 注册请求参数
export interface RegisterParams {
  username: string
  password: string
  email?: string
}

// 登录响应数据
export interface LoginResponse {
  token: string
  refreshToken?: string
  user?: UserInfo
}

export class AuthService extends BaseService {
  constructor() {
    super()
  }

  /**
   * 用户登录
   */
  async login(params: LoginParams): Promise<ApiResponse<LoginResponse>> {
    const response = await this.post<LoginResponse>('/auth/login', params)
    
    // 登录成功后，清除认证错误计数
    if (response.code === 0) {
      sessionStorage.removeItem('authErrorCount')
    }
    
    // 如果后端返回的数据结构与LoginResponse不匹配，需要转换
    // 后端实际返回: {code: 0, msg: "success", data: {token, userId, username, nickname, role}}
    // 而LoginResponse期望: {token, refreshToken?, user?}
    if (response.code === 0 && response.data && 'userId' in response.data) {
      // 保存token
      const token = (response.data as any).token
      console.log('authService.login: 准备保存token', token ? '有效' : '无效或为空')
      
      // 直接保存到localStorage和store，确保双重保险
      if (token) {
        localStorage.setItem('auth_token', token)
        console.log('authService.login: token已保存到localStorage')
      }
      
      await BaseService.setToken(token)
      
      // 转换数据结构
      const transformedData: LoginResponse = {
        token: token,
        user: {
          id: (response.data as any).userId || 0,
          username: (response.data as any).username || '',
          nickname: (response.data as any).nickname || '',
          role: (response.data as any).role || ''
        }
      }
      
      // 保存用户信息到Pinia store
      if (transformedData.user) {
        const userStore = useUserStore()
        userStore.setUserInfo(transformedData.user)
        // 设置用户ID为数字类型
        userStore.setUserId(transformedData.user.id)
      }
      
      // 返回转换后的数据
      return {
        ...response,
        data: transformedData
      }
    }
    
    // 原始逻辑处理
    if (response.code === 0 && response.data?.token) {
      // 保存token
      const token = response.data.token
      console.log('authService.login: 准备保存token', token ? '有效' : '无效或为空')
      
      // 直接保存到localStorage和store，确保双重保险
      if (token) {
        localStorage.setItem('auth_token', token)
        console.log('authService.login: token已保存到localStorage')
      }
      
      await BaseService.setToken(token)
      
      // 保存refreshToken
      if (response.data.refreshToken) {
        const userStore = useUserStore()
        userStore.setRefreshToken(response.data.refreshToken)
      }
      
      // 保存用户信息到Pinia store
      if (response.data.user) {
        const userStore = useUserStore()
        userStore.setUserInfo(response.data.user)
        // 设置用户ID为数字类型
        userStore.setUserId(response.data.user.id || 0)
      }
    }
    
    return response
  }

  /**
   * 用户注册
   */
  async register(params: RegisterParams): Promise<ApiResponse<any>> {
    return this.post('/auth/register', params)
  }

  /**
   * 用户登出
   */
  async logout(): Promise<ApiResponse<any>> {
    const response = await this.post('/auth/logout')
    
    // 无论登出是否成功，都清除本地认证信息
    await this.clearAuthInfo()
    
    return response
  }

  /**
   * 刷新token
   */
  async refreshToken(): Promise<ApiResponse<LoginResponse>> {
    const userStore = useUserStore()
    const refreshToken = userStore.getRefreshToken()
    
    if (!refreshToken) {
      return {
        code: -1,
        msg: '没有可用的刷新令牌',
        data: null as any
      }
    }

    const response = await this.post<LoginResponse>('/auth/refresh', { refreshToken })
    
    if (response.code === 0 && response.data?.token) {
      await BaseService.setToken(response.data.token)
      
      if (response.data.refreshToken) {
        userStore.setRefreshToken(response.data.refreshToken)
      }
    }
    
    return response
  }

  /**
   * 检查用户是否已登录
   * 注意：此方法已弃用，请使用 useAuthManager 中的 checkAuthStatus 方法
   * 保留此方法仅为了向后兼容
   */
  async isAuthenticated(): Promise<boolean> {
    console.warn('authService.isAuthenticated: 此方法已弃用，请使用 useAuthManager 中的 checkAuthStatus 方法')
    
    // 尝试使用 useAuthManager 的缓存机制
    try {
      const { getAuthManager } = await import('../composables/useAuthManager')
      const authManager = getAuthManager()
      return await authManager.checkAuthStatus()
    } catch (error) {
      console.error('无法使用 useAuthManager，回退到原始实现', error)
      
      // 回退到原始实现
      const token = await BaseService.getToken()
      
      // 如果没有token，直接返回false
      if (!token) {
        console.log('authService.isAuthenticated: 没有token，返回false')
        return false
      }
      
      console.log('authService.isAuthenticated: 有token，尝试验证')
      
      try {
        // 尝试调用一个需要认证的API来验证token是否有效
        // 使用一个轻量级的API端点，如获取当前用户信息
        const response = await this.get('/auth/me')
        
        // 如果API调用成功，说明token有效
        if (response.code === 0) {
          console.log('authService.isAuthenticated: /auth/me返回成功，token有效')
          // 更新用户信息
          if (response.data) {
            const userStore = useUserStore()
            userStore.setUserInfo(response.data)
            userStore.setUserId(response.data.id || 0)
          }
          return true
        }
        
        // token无效，但不要立即清除认证信息，可能是临时问题
        console.log('authService.isAuthenticated: /auth/me返回失败，但不清除认证信息')
        return false
      } catch (error: any) {
        console.error('验证token有效性失败:', error)
        
        // 如果是认证错误，不要立即清除认证信息，可能是临时问题
        // 只有在多次连续失败时才清除认证信息
        if (
          error.response?.status === 401 ||
          ((error.response?.data?.code === 401 || error.response?.data?.code === -1) && 
           error.response?.data?.msg && 
           (
             error.response.data.msg.includes('认证失败') || 
             error.response.data.msg.includes('Full authentication is required') ||
             error.response.data.msg.includes('未授权') ||
             error.response.data.msg.includes('Unauthorized')
           ))
        ) {
          console.log('authService.isAuthenticated: 认证错误，但不清除认证信息，可能是临时问题')
          
          // 检查是否是连续的认证错误
          const authErrorCount = parseInt(sessionStorage.getItem('authErrorCount') || '0')
          sessionStorage.setItem('authErrorCount', String(authErrorCount + 1))
          
          // 如果连续错误超过3次，才清除认证信息
          if (authErrorCount >= 2) {
            console.log('连续多次认证错误，清除认证信息')
            await this.clearAuthInfo()
            window.dispatchEvent(new CustomEvent('auth-error'))
            sessionStorage.removeItem('authErrorCount')
          }
          
          return false
        }
        
        return false
      }
    }
  }

  /**
   * 清除认证缓存
   * 这个方法用于配合useAuthManager的缓存机制
   */
  clearAuthCache(): void {
    // 触发认证缓存清除事件
    window.dispatchEvent(new CustomEvent('auth-cache-clear'))
    console.log('authService: 触发认证缓存清除事件')
  }

  /**
   * 获取用户信息
   */
  getUserInfo(): UserInfo | null {
    const userStore = useUserStore()
    return userStore.userInfo
  }

  /**
   * 生成游客ID
   */
  generateGuestId(): number {
    return Math.floor(100000 + Math.random() * 900000)
  }

  /**
   * 获取或创建用户ID
   */
  getOrCreateUserId(): number {
    const userStore = useUserStore()
    
    if (!userStore.userId) {
      userStore.setUserId(this.generateGuestId())
    }
    
    return userStore.userId
  }

  /**
   * 公共GET请求方法
   */
  async publicGet<T = any>(url: string, params?: any, config?: any): Promise<ApiResponse<T>> {
    return super.get<T>(url, params, config)
  }

  /**
   * 更新用户自定义配置
   */
  async updateUserCustomConfig(customConfig: any): Promise<ApiResponse<any>> {
    // 直接发送配置对象到新的/config端点
    return this.put('/user/config', customConfig)
  }

  /**
   * 清除认证信息
   */
  private async clearAuthInfo(): Promise<void> {
    await BaseService.clearToken()
    
    // 清除Pinia中的用户信息和refreshToken
    const userStore = useUserStore()
    userStore.setUserInfo(null)
    userStore.clearToken()
    
    // 清除认证错误计数
    sessionStorage.removeItem('authErrorCount')
  }
}

// 创建单例实例
export const authService = new AuthService()

export default AuthService